<?xml version="1.0" encoding="UTF-8"?>
<!--
   4xGLSLHqFilter shader
   
   Copyright (C) 2005 guest(r) - guest.r@gmail.com

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

-->
<shader language="GLSL">
    <vertex><![CDATA[
        uniform vec2 rubyTextureSize;
    	attribute vec2 aPosition;
		attribute vec2 aTexCoord;
		varying vec4 vTexCoord[7];

        void main()
        {
                vec2 dg1 = 0.5 / rubyTextureSize;
                vec2 dg2 = vec2(-dg1.x, dg1.y);
                vec2 sd1 = dg1 * 0.5;
				vec2 sd2 = dg2 * 0.5;
                vec2 ddx = vec2(dg1.x, 0.0);
				vec2 ddy = vec2(0.0, dg1.y);

                gl_Position = vec4(aPosition, 0.0, 1.0);
                vTexCoord[0].xy = aTexCoord;
                vTexCoord[1].xy = aTexCoord - sd1;
                vTexCoord[2].xy = aTexCoord - sd2;
                vTexCoord[3].xy = aTexCoord + sd1;
                vTexCoord[4].xy = aTexCoord + sd2;
                vTexCoord[5].xy = aTexCoord - dg1;
                vTexCoord[6].xy = aTexCoord + dg1;
                vTexCoord[5].zw = aTexCoord - dg2;
                vTexCoord[6].zw = aTexCoord + dg2;
                vTexCoord[1].zw = aTexCoord - ddy;
                vTexCoord[2].zw = aTexCoord + ddx;
                vTexCoord[3].zw = aTexCoord + ddy;
                vTexCoord[4].zw = aTexCoord - ddx;
        }
    ]]></vertex>
    <fragment filter="nearest" output_width="400%" output_height="400%"><![CDATA[
		#ifdef GL_FRAGMENT_PRECISION_HIGH
		precision highp float;
		#else
		precision mediump float;
		#endif
        uniform sampler2D rubyTexture;
		varying vec4 vTexCoord[7];

        const float mx = 1.00;      // start smoothing wt.
        const float k = -1.10;      // wt. decrease factor
        const float max_w = 0.75;   // max filter weigth
        const float min_w = 0.03;   // min filter weigth
        const float lum_add = 0.33; // effects smoothing

        void main()
        {
                vec3 c  = texture2D(rubyTexture, vTexCoord[0].xy).xyz;
                vec3 i1 = texture2D(rubyTexture, vTexCoord[1].xy).xyz;
                vec3 i2 = texture2D(rubyTexture, vTexCoord[2].xy).xyz;
                vec3 i3 = texture2D(rubyTexture, vTexCoord[3].xy).xyz;
                vec3 i4 = texture2D(rubyTexture, vTexCoord[4].xy).xyz;
                vec3 o1 = texture2D(rubyTexture, vTexCoord[5].xy).xyz;
                vec3 o3 = texture2D(rubyTexture, vTexCoord[6].xy).xyz;
                vec3 o2 = texture2D(rubyTexture, vTexCoord[5].zw).xyz;
                vec3 o4 = texture2D(rubyTexture, vTexCoord[6].zw).xyz;
                vec3 s1 = texture2D(rubyTexture, vTexCoord[1].zw).xyz;
                vec3 s2 = texture2D(rubyTexture, vTexCoord[2].zw).xyz;
                vec3 s3 = texture2D(rubyTexture, vTexCoord[3].zw).xyz;
                vec3 s4 = texture2D(rubyTexture, vTexCoord[4].zw).xyz;
                vec3 dt = vec3(1.0,1.0,1.0);

                float ko1=dot(abs(o1-c),dt);
                float ko2=dot(abs(o2-c),dt);
                float ko3=dot(abs(o3-c),dt);
                float ko4=dot(abs(o4-c),dt);

                float k1=min(dot(abs(i1-i3),dt),max(ko1,ko3));
                float k2=min(dot(abs(i2-i4),dt),max(ko2,ko4));

                float w1 = k2; if(ko3<ko1) w1*=ko3/ko1;
                float w2 = k1; if(ko4<ko2) w2*=ko4/ko2;
                float w3 = k2; if(ko1<ko3) w3*=ko1/ko3;
                float w4 = k1; if(ko2<ko4) w4*=ko2/ko4;

                c=(w1*o1+w2*o2+w3*o3+w4*o4+0.001*c)/(w1+w2+w3+w4+0.001);

                w1 = k*dot(abs(i1-c)+abs(i3-c),dt)/(0.125*dot(i1+i3,dt)+lum_add);
                w2 = k*dot(abs(i2-c)+abs(i4-c),dt)/(0.125*dot(i2+i4,dt)+lum_add);
                w3 = k*dot(abs(s1-c)+abs(s3-c),dt)/(0.125*dot(s1+s3,dt)+lum_add);
                w4 = k*dot(abs(s2-c)+abs(s4-c),dt)/(0.125*dot(s2+s4,dt)+lum_add);

                w1 = clamp(w1+mx,min_w,max_w); 
                w2 = clamp(w2+mx,min_w,max_w);
                w3 = clamp(w3+mx,min_w,max_w); 
                w4 = clamp(w4+mx,min_w,max_w);

                gl_FragColor.rgb=(w1*(i1+i3)+w2*(i2+i4)+w3*(s1+s3)+w4*(s2+s4)+c)/(2.0*(w1+w2+w3+w4)+1.0);
        }
    ]]></fragment>
</shader>
